/**
 * @file test_verilog_syntax.cpp
 * @brief 全面的Verilog语法测试用例
 * 覆盖各种Verilog语法场景和边界情况
 */

#include "../moparse.h"
#include <iostream>
#include <fstream>
#include <cassert>
#include <functional>
#include <cstdio>

class VerilogSyntaxTestRunner {
public:
    VerilogSyntaxTestRunner() : tests_passed_(0), tests_failed_(0) {}
    
    void run_test(const std::string& test_name, std::function<bool()> test_func) {
        std::cout << "运行测试: " << test_name << " ... ";
        try {
            if (test_func()) {
                std::cout << "通过" << std::endl;
                tests_passed_++;
            } else {
                std::cout << "失败" << std::endl;
                tests_failed_++;
            }
        } catch (const std::exception& e) {
            std::cout << "异常: " << e.what() << std::endl;
            tests_failed_++;
        }
    }
    
    void print_summary() {
        std::cout << "\nVerilog语法测试总结:" << std::endl;
        std::cout << "通过: " << tests_passed_ << std::endl;
        std::cout << "失败: " << tests_failed_ << std::endl;
        std::cout << "总计: " << (tests_passed_ + tests_failed_) << std::endl;
    }
    
    int get_failed_count() const { return tests_failed_; }

private:
    int tests_passed_;
    int tests_failed_;
};

// 创建各种Verilog语法测试文件
void create_syntax_test_files() {
    
    // 1. 基本模块定义测试
    std::ofstream basic_module("test_basic_module.v");
    basic_module << R"(
// 基本模块定义测试
module basic_module (
    input clk,
    input reset,
    output data
);
endmodule
)";
    basic_module.close();

    // 2. 参数化模块测试
    std::ofstream param_module("test_param_module.v");
    param_module << R"(
// 参数化模块测试
module param_module #(
    parameter WIDTH = 8,
    parameter DEPTH = 16,
    parameter [31:0] DEFAULT_VALUE = 32'hDEADBEEF,
    parameter ENABLE_FEATURE = 1'b1
) (
    input clk,
    input [WIDTH-1:0] data_in,
    output reg [WIDTH-1:0] data_out
);

// 本地参数
localparam ADDR_WIDTH = $clog2(DEPTH);
localparam MAX_COUNT = DEPTH - 1;

endmodule
)";
    param_module.close();

    // 3. 复杂端口声明测试
    std::ofstream port_module("test_port_module.v");
    port_module << R"(
// 复杂端口声明测试
module port_module (
    // 时钟和复位
    input wire clk,
    input wire reset_n,
    input wire async_reset,
    
    // 数据端口
    input [7:0] data_in,
    input [15:0] addr_in,
    output reg [31:0] data_out,
    output wire [7:0] status,
    
    // 控制信号
    input enable,
    input write_enable,
    input read_enable,
    output ready,
    output valid,
    
    // 双向端口
    inout [7:0] bidirectional_bus,
    
    // 数组端口
    input [3:0] select [0:7],
    output [7:0] mux_out [0:3]
);

// 内部线网声明
wire internal_clk;
wire [7:0] internal_data;
reg [15:0] counter;

endmodule
)";
    port_module.close();

    // 4. 宏定义和条件编译测试
    std::ofstream macro_module("test_macro_module.v");
    macro_module << R"(
// 宏定义和条件编译测试
`define DATA_WIDTH 16
`define ADDR_WIDTH 8
`define ENABLE_DEBUG

module macro_module (
    input clk,
    input reset,
    
`ifdef ENABLE_DEBUG
    input debug_enable,
    output [7:0] debug_data,
`endif

    input [`DATA_WIDTH-1:0] data_in,
    input [`ADDR_WIDTH-1:0] addr_in,
    output reg [`DATA_WIDTH-1:0] data_out
);

`ifdef ENABLE_CACHE
    reg [`DATA_WIDTH-1:0] cache_memory [0:(1<<`ADDR_WIDTH)-1];
`endif

`ifndef SYNTHESIS
    // 仅仿真代码
    initial begin
        $display("模块初始化");
    end
`endif

endmodule
)";
    macro_module.close();

    // 5. 复杂实例化测试
    std::ofstream inst_module("test_instance_module.v");
    inst_module << R"(
// 复杂实例化测试
module instance_module (
    input clk,
    input reset,
    input [7:0] data_in,
    output [7:0] data_out
);

// 参数化实例
param_module #(
    .WIDTH(8),
    .DEPTH(32),
    .DEFAULT_VALUE(32'h12345678),
    .ENABLE_FEATURE(1'b0)
) u_param_inst (
    .clk(clk),
    .data_in(data_in),
    .data_out(data_out)
);

// 基本实例
basic_module u_basic_inst (
    .clk(clk),
    .reset(reset),
    .data(data_out[0])
);

// 数组实例
genvar i;
generate
    for (i = 0; i < 4; i = i + 1) begin : gen_array
        basic_module u_array_inst (
            .clk(clk),
            .reset(reset),
            .data(data_out[i])
        );
    end
endgenerate

endmodule
)";
    inst_module.close();

    // 6. 存储器和数组测试
    std::ofstream memory_module("test_memory_module.v");
    memory_module << R"(
// 存储器和数组测试
module memory_module #(
    parameter DATA_WIDTH = 32,
    parameter ADDR_WIDTH = 10,
    parameter DEPTH = 1024
) (
    input clk,
    input reset,
    input [ADDR_WIDTH-1:0] addr,
    input [DATA_WIDTH-1:0] wdata,
    input we,
    input re,
    output reg [DATA_WIDTH-1:0] rdata
);

// 存储器声明
reg [DATA_WIDTH-1:0] memory [0:DEPTH-1];
reg [DATA_WIDTH-1:0] register_file [0:31];

// 二维数组
reg [7:0] matrix [0:15][0:15];

// 打包数组
reg [3:0][7:0] packed_array;

// 线网数组
wire [7:0] bus_array [0:7];

endmodule
)";
    memory_module.close();

    // 7. 系统函数和任务测试
    std::ofstream system_module("test_system_module.v");
    system_module << R"(
// 系统函数和任务测试
module system_module #(
    parameter WIDTH = 8
) (
    input clk,
    input [WIDTH-1:0] data_in,
    output [WIDTH-1:0] data_out
);

// 使用系统函数的参数
localparam ADDR_BITS = $clog2(256);
localparam HIGH_BIT = $high(data_in);
localparam LOW_BIT = $low(data_in);
localparam SIZE = $size(data_in);

// 位操作函数
wire parity = ^data_in;
wire [WIDTH-1:0] reversed = {<<{data_in}};

// 数学函数
localparam SQRT_VAL = $sqrt(256);
localparam POW_VAL = $pow(2, 8);

endmodule
)";
    system_module.close();

    // 8. 接口和modport测试
    std::ofstream interface_module("test_interface_module.v");
    interface_module << R"(
// 接口测试（SystemVerilog风格，简化处理）
interface bus_if #(parameter WIDTH = 8) (input clk);
    logic [WIDTH-1:0] data;
    logic valid;
    logic ready;
    
    modport master (
        output data, valid,
        input ready
    );
    
    modport slave (
        input data, valid,
        output ready
    );
endinterface

module interface_module (
    input clk,
    bus_if.master master_bus,
    bus_if.slave slave_bus
);

assign slave_bus.data = master_bus.data;
assign slave_bus.valid = master_bus.valid;
assign master_bus.ready = slave_bus.ready;

endmodule
)";
    interface_module.close();

    // 9. 生成块测试
    std::ofstream generate_module("test_generate_module.v");
    generate_module << R"(
// 生成块测试
module generate_module #(
    parameter NUM_STAGES = 4,
    parameter DATA_WIDTH = 8
) (
    input clk,
    input reset,
    input [DATA_WIDTH-1:0] data_in,
    output [DATA_WIDTH-1:0] data_out
);

// 生成变量
genvar i, j;

// 条件生成
generate
    if (NUM_STAGES > 1) begin : gen_pipeline
        reg [DATA_WIDTH-1:0] stage_data [0:NUM_STAGES-1];
        
        always @(posedge clk) begin
            if (reset) begin
                for (int k = 0; k < NUM_STAGES; k = k + 1) begin
                    stage_data[k] <= 0;
                end
            end else begin
                stage_data[0] <= data_in;
                for (int k = 1; k < NUM_STAGES; k = k + 1) begin
                    stage_data[k] <= stage_data[k-1];
                end
            end
        end
        
        assign data_out = stage_data[NUM_STAGES-1];
    end else begin : gen_bypass
        assign data_out = data_in;
    end
endgenerate

// 循环生成
generate
    for (i = 0; i < 4; i = i + 1) begin : gen_array
        wire [7:0] local_data;
        
        for (j = 0; j < 8; j = j + 1) begin : gen_bit
            assign local_data[j] = data_in[j] ^ i[j%2];
        end
    end
endgenerate

endmodule
)";
    generate_module.close();

    // 10. 复杂数据类型测试
    std::ofstream datatype_module("test_datatype_module.v");
    datatype_module << R"(
// 复杂数据类型测试
module datatype_module (
    input clk,
    input reset
);

// 基本数据类型
reg signed [15:0] signed_reg;
reg unsigned [15:0] unsigned_reg;
wire signed [7:0] signed_wire;

// 实数类型
real real_var;
realtime time_var;

// 字符串类型
reg [8*10-1:0] string_reg;  // 10字符字符串

// 枚举类型（SystemVerilog）
typedef enum logic [1:0] {
    IDLE = 2'b00,
    ACTIVE = 2'b01,
    WAIT = 2'b10,
    ERROR = 2'b11
} state_t;

state_t current_state, next_state;

// 结构体类型（SystemVerilog）
typedef struct packed {
    logic [7:0] opcode;
    logic [3:0] dest;
    logic [3:0] src1;
    logic [3:0] src2;
} instruction_t;

instruction_t instruction;

// 联合类型
typedef union packed {
    logic [31:0] word;
    logic [15:0] half_word [0:1];
    logic [7:0] byte [0:3];
} data_union_t;

data_union_t data_union;

endmodule
)";
    datatype_module.close();

    // 11. 时序控制和事件测试
    std::ofstream timing_module("test_timing_module.v");
    timing_module << R"(
// 时序控制和事件测试
module timing_module (
    input clk,
    input reset,
    input [7:0] data_in,
    output reg [7:0] data_out
);

// 事件声明
event data_ready;
event process_complete;

// 不同的时序控制
always @(posedge clk or negedge reset) begin
    if (!reset) begin
        data_out <= 8'h00;
    end else begin
        data_out <= data_in;
    end
end

// 组合逻辑
always @(*) begin
    // 组合逻辑
end

// 上升沿和下降沿
always @(posedge clk) begin
    // 时钟上升沿
end

always @(negedge clk) begin
    // 时钟下降沿
end

// 电平敏感
always @(reset) begin
    if (reset) begin
        // 复位处理
    end
end

// 多个信号
always @(posedge clk or posedge reset or data_in) begin
    // 多信号敏感
end

endmodule
)";
    timing_module.close();

    // 12. 任务和函数测试
    std::ofstream task_function_module("test_task_function_module.v");
    task_function_module << R"(
// 任务和函数测试
module task_function_module (
    input clk,
    input [7:0] data_in,
    output reg [7:0] data_out
);

// 函数定义
function [7:0] reverse_bits;
    input [7:0] in_data;
    integer i;
    begin
        for (i = 0; i < 8; i = i + 1) begin
            reverse_bits[i] = in_data[7-i];
        end
    end
endfunction

// 递归函数
function [31:0] factorial;
    input [31:0] n;
    begin
        if (n <= 1)
            factorial = 1;
        else
            factorial = n * factorial(n - 1);
    end
endfunction

// 任务定义
task reset_registers;
    begin
        data_out <= 8'h00;
        // 其他复位操作
    end
endtask

// 带参数的任务
task shift_data;
    input [7:0] in_data;
    input [2:0] shift_amount;
    output [7:0] out_data;
    begin
        out_data = in_data << shift_amount;
    end
endtask

// 使用函数和任务
always @(posedge clk) begin
    data_out <= reverse_bits(data_in);
end

endmodule
)";
    task_function_module.close();

    // 创建文件列表
    std::ofstream syntax_filelist("syntax_test.list");
    syntax_filelist << "test_basic_module.v\n";
    syntax_filelist << "test_param_module.v\n";
    syntax_filelist << "test_port_module.v\n";
    syntax_filelist << "test_macro_module.v\n";
    syntax_filelist << "test_instance_module.v\n";
    syntax_filelist << "test_memory_module.v\n";
    syntax_filelist << "test_system_module.v\n";
    syntax_filelist << "test_interface_module.v\n";
    syntax_filelist << "test_generate_module.v\n";
    syntax_filelist << "test_datatype_module.v\n";
    syntax_filelist << "test_timing_module.v\n";
    syntax_filelist << "test_task_function_module.v\n";
    syntax_filelist.close();
}

// 清理语法测试文件
void cleanup_syntax_test_files() {
    std::vector<std::string> files = {
        "test_basic_module.v", "test_param_module.v", "test_port_module.v",
        "test_macro_module.v", "test_instance_module.v", "test_memory_module.v",
        "test_system_module.v", "test_interface_module.v", "test_generate_module.v",
        "test_datatype_module.v", "test_timing_module.v", "test_task_function_module.v",
        "syntax_test.list", "syntax_output.modb", "temp_test.modb"
    };
    
    for (const auto& file : files) {
        std::remove(file.c_str());
    }
}

// 测试基本模块解析
bool test_basic_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_basic_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "basic_module" && module.ports_size() == 3;
}

// 测试参数化模块解析
bool test_param_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_param_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    if (module.name() != "param_module") {
        return false;
    }
    
    // 检查参数数量
    if (module.parameters_size() < 4) {
        return false;
    }
    
    // 检查特定参数
    bool has_width = false;
    bool has_depth = false;
    for (const auto& param : module.parameters()) {
        if (param.name() == "WIDTH" && param.value() == "8") {
            has_width = true;
        }
        if (param.name() == "DEPTH" && param.value() == "16") {
            has_depth = true;
        }
    }
    
    return has_width && has_depth;
}

// 测试复杂端口解析
bool test_port_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_port_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    if (module.name() != "port_module") {
        return false;
    }
    
    // 检查端口数量（应该有多个端口）
    if (module.ports_size() < 10) {
        return false;
    }
    
    // 检查特定端口类型
    bool has_input = false;
    bool has_output = false;
    bool has_inout = false;
    
    for (const auto& port : module.ports()) {
        if (port.direction() == "input") has_input = true;
        if (port.direction() == "output") has_output = true;
        if (port.direction() == "inout") has_inout = true;
    }
    
    return has_input && has_output && has_inout;
}

// 测试宏定义模块解析
bool test_macro_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_macro_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "macro_module" && module.ports_size() >= 3;
}

// 测试实例化模块解析
bool test_instance_module_parsing() {
    VerilogParser parser;
    
    // 需要先解析依赖的模块
    if (!parser.parseVerilogFile("test_param_module.v")) {
        return false;
    }
    
    if (!parser.parseVerilogFile("test_basic_module.v")) {
        return false;
    }
    
    if (!parser.parseVerilogFile("test_instance_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() < 3) {
        return false;
    }
    
    // 查找实例化模块
    const modb::Module* inst_module = nullptr;
    for (const auto& module : db.modules()) {
        if (module.name() == "instance_module") {
            inst_module = &module;
            break;
        }
    }
    
    if (!inst_module) {
        return false;
    }
    
    // 检查是否有实例
    return inst_module->instances_size() >= 2;
}

// 测试存储器模块解析
bool test_memory_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_memory_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "memory_module" && module.parameters_size() >= 3;
}

// 测试系统函数模块解析
bool test_system_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_system_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "system_module";
}

// 测试生成块模块解析
bool test_generate_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_generate_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "generate_module" && module.parameters_size() >= 2;
}

// 测试任务函数模块解析
bool test_task_function_module_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_task_function_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "task_function_module";
}

// 测试所有语法文件的批量解析
bool test_batch_syntax_parsing() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFileList("syntax_test.list")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    
    // 应该解析出多个模块
    if (db.modules_size() < 8) {  // 至少应该有8个模块
        return false;
    }
    
    // 保存结果
    return parser.saveToModb("syntax_output.modb");
}

// 测试语法错误处理
bool test_syntax_error_handling() {
    // 创建有语法错误的文件
    std::ofstream error_file("test_syntax_error.v");
    error_file << R"(
// 语法错误测试
module syntax_error_module (
    input clk,
    input reset
    // 故意缺少右括号和endmodule
)";
    error_file.close();
    
    VerilogParser parser;
    
    // 应该能够处理语法错误（不崩溃）
    bool result = parser.parseVerilogFile("test_syntax_error.v");
    
    // 清理错误文件
    std::remove("test_syntax_error.v");
    
    // 返回false表示正确检测到了语法错误
    return !result;
}

// 测试反向生成各种语法模块
bool test_reverse_generation_syntax() {
    VerilogParser parser;
    
    // 解析复杂的参数化模块
    if (!parser.parseVerilogFile("test_param_module.v")) {
        return false;
    }
    
    if (!parser.saveToModb("temp_test.modb")) {
        return false;
    }
    
    // 测试生成空壳模块
    if (!parser.generateVerilog("temp_test.modb", "param_module", "param_empty.v", "e")) {
        return false;
    }
    
    // 测试生成stub模块
    if (!parser.generateVerilog("temp_test.modb", "param_module", "param_stub.v", "es")) {
        return false;
    }
    
    // 验证生成的文件
    std::ifstream empty_file("param_empty.v");
    std::ifstream stub_file("param_stub.v");
    
    bool result = empty_file.is_open() && stub_file.is_open();
    
    // 清理生成的文件
    std::remove("param_empty.v");
    std::remove("param_stub.v");
    
    return result;
}

int main() {
    std::cout << "开始Verilog语法全面测试...\n" << std::endl;
    
    // 创建语法测试文件
    create_syntax_test_files();
    
    VerilogSyntaxTestRunner runner;
    
    // 运行各种语法测试
    runner.run_test("基本模块解析", test_basic_module_parsing);
    runner.run_test("参数化模块解析", test_param_module_parsing);
    runner.run_test("复杂端口解析", test_port_module_parsing);
    runner.run_test("宏定义模块解析", test_macro_module_parsing);
    runner.run_test("实例化模块解析", test_instance_module_parsing);
    runner.run_test("存储器模块解析", test_memory_module_parsing);
    runner.run_test("系统函数模块解析", test_system_module_parsing);
    runner.run_test("生成块模块解析", test_generate_module_parsing);
    runner.run_test("任务函数模块解析", test_task_function_module_parsing);
    runner.run_test("批量语法解析", test_batch_syntax_parsing);
    runner.run_test("语法错误处理", test_syntax_error_handling);
    runner.run_test("反向生成语法测试", test_reverse_generation_syntax);
    
    // 清理测试文件
    cleanup_syntax_test_files();
    
    // 输出测试结果
    runner.print_summary();
    
    return runner.get_failed_count() > 0 ? 1 : 0;
}